home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / db3 / db_cxx.h < prev    next >
C/C++ Source or Header  |  2005-10-19  |  19KB  |  653 lines
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997, 1998, 1999, 2000
  5.  *    Sleepycat Software.  All rights reserved.
  6.  *
  7.  * $Id: db_cxx.h,v 11.44 2000/12/21 20:30:18 dda Exp $
  8.  */
  9.  
  10. #ifndef _DB_CXX_H_
  11. #define    _DB_CXX_H_
  12. //
  13. // C++ assumptions:
  14. //
  15. // To ensure portability to many platforms, both new and old, we make
  16. // few assumptions about the C++ compiler and library.  For example,
  17. // we do not expect STL, templates or namespaces to be available.  The
  18. // "newest" C++ feature used is exceptions, which are used liberally
  19. // to transmit error information.  Even the use of exceptions can be
  20. // disabled at runtime, to do so, use the DB_CXX_NO_EXCEPTIONS flags
  21. // with the DbEnv or Db constructor.
  22. //
  23. // C++ naming conventions:
  24. //
  25. //  - All top level class names start with Db.
  26. //  - All class members start with lower case letter.
  27. //  - All private data members are suffixed with underscore.
  28. //  - Use underscores to divide names into multiple words.
  29. //  - Simple data accessors are named with get_ or set_ prefix.
  30. //  - All method names are taken from names of functions in the C
  31. //    layer of db (usually by dropping a prefix like "db_").
  32. //    These methods have the same argument types and order,
  33. //    other than dropping the explicit arg that acts as "this".
  34. //
  35. // As a rule, each DbFoo object has exactly one underlying DB_FOO struct
  36. // (defined in db.h) associated with it.  In some cases, we inherit directly
  37. // from the DB_FOO structure to make this relationship explicit.  Often,
  38. // the underlying C layer allocates and deallocates these structures, so
  39. // there is no easy way to add any data to the DbFoo class.  When you see
  40. // a comment about whether data is permitted to be added, this is what
  41. // is going on.  Of course, if we need to add data to such C++ classes
  42. // in the future, we will arrange to have an indirect pointer to the
  43. // DB_FOO struct (as some of the classes already have).
  44. //
  45.  
  46. ////////////////////////////////////////////////////////////////
  47. ////////////////////////////////////////////////////////////////
  48. //
  49. // Forward declarations
  50. //
  51.  
  52. #include <iostream.h>
  53. #include <stdarg.h>
  54. #include "db.h"
  55.  
  56. class Db;                                        // forward
  57. class Dbc;                                       // forward
  58. class DbEnv;                                     // forward
  59. class DbException;                               // forward
  60. class DbInfo;                                    // forward
  61. class DbLock;                                    // forward
  62. class DbLsn;                                     // forward
  63. class DbMpoolFile;                               // forward
  64. class Dbt;                                       // forward
  65. class DbTxn;                                     // forward
  66.  
  67. // These classes are not defined here and should be invisible
  68. // to the user, but some compilers require forward references.
  69. // There is one for each use of the DEFINE_DB_CLASS macro.
  70.  
  71. class DbImp;
  72. class DbEnvImp;
  73. class DbMpoolFileImp;
  74. class DbTxnImp;
  75.  
  76. ////////////////////////////////////////////////////////////////
  77. ////////////////////////////////////////////////////////////////
  78. //
  79. // Mechanisms for declaring classes
  80. //
  81.  
  82. //
  83. // Every class defined in this file has an _exported next to the class name.
  84. // This is needed for WinTel machines so that the class methods can
  85. // be exported or imported in a DLL as appropriate.  Users of the DLL
  86. // use the define DB_USE_DLL.  When the DLL is built, DB_CREATE_DLL
  87. // must be defined.
  88. //
  89. #if defined(_MSC_VER)
  90.  
  91. #  if defined(DB_CREATE_DLL)
  92. #    define _exported __declspec(dllexport)      // creator of dll
  93. #  elif defined(DB_USE_DLL)
  94. #    define _exported __declspec(dllimport)      // user of dll
  95. #  else
  96. #    define _exported                            // static lib creator or user
  97. #  endif
  98.  
  99. #else
  100.  
  101. #  define _exported
  102.  
  103. #endif
  104.  
  105. // DEFINE_DB_CLASS defines an imp_ data member and imp() accessor.
  106. // The underlying type is a pointer to an opaque *Imp class, that
  107. // gets converted to the correct implementation class by the implementation.
  108. //
  109. // Since these defines use "private/public" labels, and leave the access
  110. // being "private", we always use these by convention before any data
  111. // members in the private section of a class.  Keeping them in the
  112. // private section also emphasizes that they are off limits to user code.
  113. //
  114. #define    DEFINE_DB_CLASS(name) \
  115.     public: class name##Imp* imp() { return (imp_); } \
  116.     public: const class name##Imp* constimp() const { return (imp_); } \
  117.     private: class name##Imp* imp_
  118.  
  119. ////////////////////////////////////////////////////////////////
  120. ////////////////////////////////////////////////////////////////
  121. //
  122. // Turn off inappropriate compiler warnings
  123. //
  124.  
  125. #ifdef _MSC_VER
  126.  
  127. // These are level 4 warnings that are explicitly disabled.
  128. // With Visual C++, by default you do not see above level 3 unless
  129. // you use /W4.  But we like to compile with the highest level
  130. // warnings to catch other errors.
  131. //
  132. // 4201: nameless struct/union
  133. //       triggered by standard include file <winnt.h>
  134. //
  135. // 4514: unreferenced inline function has been removed
  136. //       certain include files in MSVC define methods that are not called
  137. //
  138. #pragma warning(disable: 4201 4514)
  139.  
  140. #endif
  141.  
  142. // Some interfaces can be customized by allowing users
  143. // to define callback functions.  For performance and
  144. // logistical reasons, some callbacks require you do
  145. // declare the functions in C, or in an extern "C" block.
  146. //
  147. extern "C" {
  148.     typedef void * (*db_malloc_fcn_type)
  149.         (size_t);
  150.     typedef void * (*db_realloc_fcn_type)
  151.         (void *, size_t);
  152.     typedef int (*bt_compare_fcn_type)
  153.         (DB *, const DBT *, const DBT *);
  154.     typedef size_t (*bt_prefix_fcn_type)
  155.         (DB *, const DBT *, const DBT *);
  156.     typedef int (*dup_compare_fcn_type)
  157.         (DB *, const DBT *, const DBT *);
  158.     typedef u_int32_t (*h_hash_fcn_type)
  159.         (DB *, const void *, u_int32_t);
  160.     typedef int (*pgin_fcn_type)(DB_ENV *dbenv,
  161.          db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
  162.     typedef int (*pgout_fcn_type)(DB_ENV *dbenv,
  163.          db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
  164. };
  165.  
  166. ////////////////////////////////////////////////////////////////
  167. ////////////////////////////////////////////////////////////////
  168. //
  169. // Exception classes
  170. //
  171.  
  172. // Almost any error in the DB library throws a DbException.
  173. // Every exception should be considered an abnormality
  174. // (e.g. bug, misuse of DB, file system error).
  175. //
  176. // NOTE: We would like to inherit from class exception and
  177. //       let it handle what(), but there are
  178. //       MSVC++ problems when <exception> is included.
  179. //
  180. class _exported DbException
  181. {
  182. public:
  183.     virtual ~DbException();
  184.     DbException(int err);
  185.     DbException(const char *description);
  186.     DbException(const char *prefix, int err);
  187.     DbException(const char *prefix1, const char *prefix2, int err);
  188.     int get_errno() const;
  189.     virtual const char *what() const;
  190.  
  191.     DbException(const DbException &);
  192.     DbException &operator = (const DbException &);
  193.  
  194. private:
  195.     char *what_;
  196.     int err_;                   // errno
  197. };
  198.  
  199. ////////////////////////////////////////////////////////////////
  200. ////////////////////////////////////////////////////////////////
  201. //
  202. // Lock classes
  203. //
  204.  
  205. class _exported DbLock
  206. {
  207.     friend class DbEnv;
  208.  
  209. public:
  210.     DbLock();
  211.  
  212.     int put(DbEnv *env);
  213.  
  214.     DbLock(const DbLock &);
  215.     DbLock &operator = (const DbLock &);
  216.  
  217. protected:
  218.     // We can add data to this class if needed
  219.     // since its contained class is not allocated by db.
  220.     // (see comment at top)
  221.  
  222.     DbLock(DB_LOCK);
  223.     DB_LOCK lock_;
  224. };
  225.  
  226. ////////////////////////////////////////////////////////////////
  227. ////////////////////////////////////////////////////////////////
  228. //
  229. // Log classes
  230. //
  231.  
  232. class _exported DbLsn : protected DB_LSN
  233. {
  234.     friend class DbEnv;          // friendship needed to cast to base class
  235. };
  236.  
  237. ////////////////////////////////////////////////////////////////
  238. ////////////////////////////////////////////////////////////////
  239. //
  240. // Memory pool classes
  241. //
  242.  
  243. class _exported DbMpoolFile
  244. {
  245.     friend class DbEnv;
  246.  
  247. public:
  248.     int close();
  249.     int get(db_pgno_t *pgnoaddr, u_int32_t flags, void *pagep);
  250.     int put(void *pgaddr, u_int32_t flags);
  251.     int set(void *pgaddr, u_int32_t flags);
  252.     int sync();
  253.  
  254.     static int open(DbEnv *envp, const char *file,
  255.             u_int32_t flags, int mode, size_t pagesize,
  256.             DB_MPOOL_FINFO *finfop, DbMpoolFile **mpf);
  257.  
  258. private:
  259.     // We can add data to this class if needed
  260.     // since it is implemented via a pointer.
  261.     // (see comment at top)
  262.  
  263.     // Note: use DbMpoolFile::open()
  264.     // to get pointers to a DbMpoolFile,
  265.     // and call DbMpoolFile::close() rather than delete to release them.
  266.     //
  267.     DbMpoolFile();
  268.  
  269.     // Shut g++ up.
  270. protected:
  271.     ~DbMpoolFile();
  272.  
  273. private:
  274.     // no copying
  275.     DbMpoolFile(const DbMpoolFile &);
  276.     void operator = (const DbMpoolFile &);
  277.  
  278.     DEFINE_DB_CLASS(DbMpoolFile);
  279. };
  280.  
  281. ////////////////////////////////////////////////////////////////
  282. ////////////////////////////////////////////////////////////////
  283. //
  284. // Transaction classes
  285. //
  286.  
  287. class _exported DbTxn
  288. {
  289.     friend class DbEnv;
  290.  
  291. public:
  292.     int abort();
  293.     int commit(u_int32_t flags);
  294.     u_int32_t id();
  295.     int prepare();
  296.  
  297. private:
  298.     // We can add data to this class if needed
  299.     // since it is implemented via a pointer.
  300.     // (see comment at top)
  301.  
  302.     // Note: use DbEnv::txn_begin() to get pointers to a DbTxn,
  303.     // and call DbTxn::abort() or DbTxn::commit rather than
  304.     // delete to release them.
  305.     //
  306.     DbTxn();
  307.     ~DbTxn();
  308.  
  309.     // no copying
  310.     DbTxn(const DbTxn &);
  311.     void operator = (const DbTxn &);
  312.  
  313.     DEFINE_DB_CLASS(DbTxn);
  314. };
  315.  
  316. //
  317. // Berkeley DB environment class.  Provides functions for opening databases.
  318. // User of this library can use this class as a starting point for
  319. // developing a DB application - derive their application class from
  320. // this one, add application control logic.
  321. //
  322. // Note that if you use the default constructor, you must explicitly
  323. // call appinit() before any other db activity (e.g. opening files)
  324. //
  325. class _exported DbEnv
  326. {
  327.     friend class Db;
  328.     friend class DbLock;
  329.     friend class DbMpoolFile;
  330.  
  331. public:
  332.  
  333.     ~DbEnv();
  334.  
  335.     // After using this constructor, you can set any needed
  336.     // parameters for the environment using the set_* methods.
  337.     // Then call open() to finish initializing the environment
  338.     // and attaching it to underlying files.
  339.     //
  340.     DbEnv(u_int32_t flags);
  341.  
  342.     // These methods match those in the C interface.
  343.     //
  344.     int close(u_int32_t);
  345.     void err(int, const char *, ...);
  346.     void errx(const char *, ...);
  347.     int open(const char *, u_int32_t, int);
  348.     int remove(const char *, u_int32_t);
  349.     int set_cachesize(u_int32_t, u_int32_t, int);
  350.     int set_data_dir(const char *);
  351.     void set_errcall(void (*)(const char *, char *));
  352.     void set_errfile(FILE *);
  353.     void set_errpfx(const char *);
  354.     int set_flags(u_int32_t, int);
  355.     int set_feedback(void (*)(DbEnv *, int, int));
  356.     int set_recovery_init(int (*)(DbEnv *));
  357.     int set_lg_bsize(u_int32_t);
  358.     int set_lg_dir(const char *);
  359.     int set_lg_max(u_int32_t);
  360.     int set_lk_conflicts(u_int8_t *, int);
  361.     int set_lk_detect(u_int32_t);
  362.     int set_lk_max(u_int32_t);
  363.     int set_lk_max_lockers(u_int32_t);
  364.     int set_lk_max_locks(u_int32_t);
  365.     int set_lk_max_objects(u_int32_t);
  366.     int set_mp_mmapsize(size_t);
  367.     int set_mutexlocks(int);
  368.     static int set_pageyield(int);
  369.     int set_paniccall(void (*)(DbEnv *, int));
  370.     static int set_panicstate(int);
  371.     static int set_region_init(int);
  372.     int set_server(char *, long, long, u_int32_t);
  373.     int set_shm_key(long);
  374.     int set_tmp_dir(const char *);
  375.     static int set_tas_spins(u_int32_t);
  376.     int set_tx_max(u_int32_t);
  377.     int set_tx_recover(int (*)(DbEnv *, Dbt *, DbLsn *, db_recops));
  378.     int set_tx_timestamp(time_t *);
  379.     int set_verbose(u_int32_t which, int onoff);
  380.  
  381.     // Version information.  A static method so it can be obtained anytime.
  382.     //
  383.     static char *version(int *major, int *minor, int *patch);
  384.  
  385.     // Convert DB errors to strings
  386.     static char *strerror(int);
  387.  
  388.     // If an error is detected and the error call function
  389.     // or stream is set, a message is dispatched or printed.
  390.     // If a prefix is set, each message is prefixed.
  391.     //
  392.     // You can use set_errcall() or set_errfile() above to control
  393.     // error functionality.  Alternatively, you can call
  394.     // set_error_stream() to force all errors to a C++ stream.
  395.     // It is unwise to mix these approaches.
  396.     //
  397.     void set_error_stream(ostream *);
  398.  
  399.     // used internally
  400.     static void runtime_error(const char *caller, int err,
  401.                   int error_policy);
  402.  
  403.     // Lock functions
  404.     //
  405.     int lock_detect(u_int32_t flags, u_int32_t atype, int *aborted);
  406.     int lock_get(u_int32_t locker, u_int32_t flags, const Dbt *obj,
  407.              db_lockmode_t lock_mode, DbLock *lock);
  408.     int lock_id(u_int32_t *idp);
  409.     int lock_stat(DB_LOCK_STAT **statp, db_malloc_fcn_type db_malloc_fcn);
  410.     int lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ list[],
  411.              int nlist, DB_LOCKREQ **elistp);
  412.  
  413.     // Log functions
  414.     //
  415.     int log_archive(char **list[], u_int32_t flags, db_malloc_fcn_type db_malloc_fcn);
  416.     static int log_compare(const DbLsn *lsn0, const DbLsn *lsn1);
  417.     int log_file(DbLsn *lsn, char *namep, size_t len);
  418.     int log_flush(const DbLsn *lsn);
  419.     int log_get(DbLsn *lsn, Dbt *data, u_int32_t flags);
  420.     int log_put(DbLsn *lsn, const Dbt *data, u_int32_t flags);
  421.  
  422.     int log_register(Db *dbp, const char *name);
  423.     int log_stat(DB_LOG_STAT **spp, db_malloc_fcn_type db_malloc_fcn);
  424.     int log_unregister(Db *dbp);
  425.  
  426.     // Mpool functions
  427.     //
  428.     int memp_register(int ftype,
  429.               pgin_fcn_type pgin_fcn,
  430.               pgout_fcn_type pgout_fcn);
  431.  
  432.     int memp_stat(DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp,
  433.               db_malloc_fcn_type db_malloc_fcn);
  434.     int memp_sync(DbLsn *lsn);
  435.     int memp_trickle(int pct, int *nwrotep);
  436.  
  437.     // Transaction functions
  438.     //
  439.     int txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags);
  440.     int txn_checkpoint(u_int32_t kbyte, u_int32_t min, u_int32_t flags);
  441.     int txn_stat(DB_TXN_STAT **statp, db_malloc_fcn_type db_malloc_fcn);
  442.  
  443.     // These are public only because they need to be called
  444.     // via C functions.  They should never be called by users
  445.     // of this class.
  446.     //
  447.     static void _stream_error_function(const char *, char *);
  448.     static int _tx_recover_intercept(DB_ENV *env, DBT *dbt, DB_LSN *lsn,
  449.                     db_recops op);
  450.     static void _paniccall_intercept(DB_ENV *env, int errval);
  451.     static int _recovery_init_intercept(DB_ENV *env);
  452.     static void _feedback_intercept(DB_ENV *env, int opcode, int pct);
  453.     static void _destroy_check(const char *str, int isDbEnv);
  454.  
  455. private:
  456.     void cleanup();
  457.     int initialize(DB_ENV *env);
  458.     int error_policy();
  459.  
  460.     // Used internally
  461.     DbEnv(DB_ENV *, u_int32_t flags);
  462.  
  463.     // no copying
  464.     DbEnv(const DbEnv &);
  465.     void operator = (const DbEnv &);
  466.  
  467.     DEFINE_DB_CLASS(DbEnv);
  468.  
  469.     // instance data
  470.     int construct_error_;
  471.     u_int32_t construct_flags_;
  472.     Db *headdb_;
  473.     Db *taildb_;
  474.     int (*tx_recover_callback_)(DbEnv *, Dbt *, DbLsn *, db_recops);
  475.     int (*recovery_init_callback_)(DbEnv *);
  476.     void (*paniccall_callback_)(DbEnv *, int);
  477.     void (*feedback_callback_)(DbEnv *, int, int);
  478.  
  479.     // class data
  480.     static ostream *error_stream_;
  481. };
  482.  
  483. ////////////////////////////////////////////////////////////////
  484. ////////////////////////////////////////////////////////////////
  485. //
  486. // Table access classes
  487. //
  488.  
  489. //
  490. // Represents a database table = a set of keys with associated values.
  491. //
  492. class _exported Db
  493. {
  494.     friend class DbEnv;
  495.  
  496. public:
  497.     Db(DbEnv*, u_int32_t);      // create a Db object, then call open()
  498.     ~Db();                      // does *not* call close.
  499.  
  500.     // These methods exactly match those in the C interface.
  501.     //
  502.     int close(u_int32_t flags);
  503.     int cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags);
  504.     int del(DbTxn *txnid, Dbt *key, u_int32_t flags);
  505.     void err(int, const char *, ...);
  506.     void errx(const char *, ...);
  507.     int fd(int *fdp);
  508.     int get(DbTxn *txnid, Dbt *key, Dbt *data, u_int32_t flags);
  509.     int get_byteswapped() const;
  510.     DBTYPE get_type() const;
  511.     int join(Dbc **curslist, Dbc **dbcp, u_int32_t flags);
  512.     int key_range(DbTxn *, Dbt *, DB_KEY_RANGE *, u_int32_t);
  513.     int open(const char *, const char *subname, DBTYPE, u_int32_t, int);
  514.     int put(DbTxn *, Dbt *, Dbt *, u_int32_t);
  515.     int remove(const char *, const char *, u_int32_t);
  516.     int rename(const char *, const char *, const char *, u_int32_t);
  517.     int set_bt_compare(bt_compare_fcn_type);
  518.     int set_bt_maxkey(u_int32_t);
  519.     int set_bt_minkey(u_int32_t);
  520.     int set_bt_prefix(bt_prefix_fcn_type);
  521.     int set_cachesize(u_int32_t, u_int32_t, int);
  522.     int set_dup_compare(dup_compare_fcn_type);
  523.     void set_errcall(void (*)(const char *, char *));
  524.     void set_errfile(FILE *);
  525.     void set_errpfx(const char *);
  526.     int set_append_recno(int (*)(Db *, Dbt *, db_recno_t));
  527.     int set_feedback(void (*)(Db *, int, int));
  528.     int set_flags(u_int32_t);
  529.     int set_h_ffactor(u_int32_t);
  530.     int set_h_hash(h_hash_fcn_type);
  531.     int set_h_nelem(u_int32_t);
  532.     int set_lorder(int);
  533.     int set_malloc(db_malloc_fcn_type);
  534.     int set_pagesize(u_int32_t);
  535.     int set_paniccall(void (*)(DbEnv *, int));
  536.     int set_realloc(db_realloc_fcn_type);
  537.     int set_re_delim(int);
  538.     int set_re_len(u_int32_t);
  539.     int set_re_pad(int);
  540.     int set_re_source(char *);
  541.     int set_q_extentsize(u_int32_t);
  542.     int stat(void *sp, db_malloc_fcn_type db_malloc_fcn, u_int32_t flags);
  543.     int sync(u_int32_t flags);
  544.     int upgrade(const char *name, u_int32_t flags);
  545.     int verify(const char *, const char *, ostream *, u_int32_t);
  546.  
  547.     // This additional method is available for C++
  548.     //
  549.     void set_error_stream(ostream *);
  550.  
  551.     // These are public only because it needs to be called
  552.     // via C functions.  It should never be called by users
  553.     // of this class.
  554.     //
  555.     static void _feedback_intercept(DB *db, int opcode, int pct);
  556.     static int _append_recno_intercept(DB *db, DBT *data, db_recno_t recno);
  557. private:
  558.  
  559.     // no copying
  560.     Db(const Db &);
  561.     Db &operator = (const Db &);
  562.  
  563.     DEFINE_DB_CLASS(Db);
  564.  
  565.     void cleanup();
  566.     int initialize();
  567.     int error_policy();
  568.  
  569.     // instance data
  570.     DbEnv *env_;
  571.     Db *next_;
  572.     Db *prev_;
  573.     int construct_error_;
  574.     u_int32_t flags_;
  575.     u_int32_t construct_flags_;
  576.     void (*feedback_callback_)(Db *, int, int);
  577.     int (*append_recno_callback_)(Db *, Dbt *, db_recno_t);
  578. };
  579.  
  580. //
  581. // A chunk of data, maybe a key or value.
  582. //
  583. class _exported Dbt : private DBT
  584. {
  585.     friend class Dbc;
  586.     friend class Db;
  587.     friend class DbEnv;
  588.  
  589. public:
  590.  
  591.     // key/data
  592.     void *get_data() const;
  593.     void set_data(void *);
  594.  
  595.     // key/data length
  596.     u_int32_t get_size() const;
  597.     void set_size(u_int32_t);
  598.  
  599.     // RO: length of user buffer.
  600.     u_int32_t get_ulen() const;
  601.     void set_ulen(u_int32_t);
  602.  
  603.     // RO: get/put record length.
  604.     u_int32_t get_dlen() const;
  605.     void set_dlen(u_int32_t);
  606.  
  607.     // RO: get/put record offset.
  608.     u_int32_t get_doff() const;
  609.     void set_doff(u_int32_t);
  610.  
  611.     // flags
  612.     u_int32_t get_flags() const;
  613.     void set_flags(u_int32_t);
  614.  
  615.     Dbt(void *data, size_t size);
  616.     Dbt();
  617.     ~Dbt();
  618.     Dbt(const Dbt &);
  619.     Dbt &operator = (const Dbt &);
  620.  
  621. private:
  622.     // We can add data to this class if needed
  623.     // since parent class is not allocated by db.
  624.     // (see comment at top)
  625. };
  626.  
  627. class _exported Dbc : protected DBC
  628. {
  629.     friend class Db;
  630.  
  631. public:
  632.     int close();
  633.     int count(db_recno_t *countp, u_int32_t flags);
  634.     int del(u_int32_t flags);
  635.     int dup(Dbc** cursorp, u_int32_t flags);
  636.     int get(Dbt* key, Dbt *data, u_int32_t flags);
  637.     int put(Dbt* key, Dbt *data, u_int32_t flags);
  638.  
  639. private:
  640.     // No data is permitted in this class (see comment at top)
  641.  
  642.     // Note: use Db::cursor() to get pointers to a Dbc,
  643.     // and call Dbc::close() rather than delete to release them.
  644.     //
  645.     Dbc();
  646.     ~Dbc();
  647.  
  648.     // no copying
  649.     Dbc(const Dbc &);
  650.     Dbc &operator = (const Dbc &);
  651. };
  652. #endif /* !_DB_CXX_H_ */
  653.